#include<iostream>
using namespace std;

// class A {};
// class B : public A {};

// class Person {
// public:
// 	virtual A* BuyTicket() {
// 		cout << "买票-全价" << endl;
// 		return nullptr;
// 	}

// 	// destructor()  析构函数悄悄该成destructor，为了子类析构函数够成重写
// 	virtual ~Person() { cout << "~Person()" << endl; }
// };

// class Student : public Person {
// public:
// 	// 重写
// 	virtual B* BuyTicket() {
// 		cout << "买票-半价" << endl;
// 		return nullptr;
// 	}

// 	// destructor()
// 	virtual ~Student()
// 	{ 
// 		cout << "delete[]" << _ptr << endl;

// 		delete[] _ptr;
// 		cout << "~Student()" << endl;
// 	}

// private:
// 	int* _ptr = new int[10];
// };

// // 多态的条件
// // 1、虚函数的重写 （父子类虚函数，要求三同（函数名、参数、返回值））
// // 2、父类的指针或者引用去调用

// void Func(Person& p)
// {
// 	p.BuyTicket();
// }

// //int main()
// //{
// //	Person ps;
// //	Student st;
// //
// //	Func(ps);
// //	Func(st);
// //
// //	return 0;
// //}

// int main()
// {
// 	//Person p;
// 	//Student s;

// 	Person* p1 = new Person;
// 	Person* p2 = new Student;

// 	// p1->destructor + operator delete(p1)
// 	// p2->destructor + operator delete(p2)
// 	// 多态
// 	// 期望：指向父类调用父类析构
// 	// 期望：指向子类调用子类析构
// 	// 结论：建议析构函数定义为虚函数，防止发生内存泄漏
// 	delete p1;
// 	delete p2;

// 	return 0;
// }

// A: A->0 B : B->1 C : A->1 D : B->0 E : 编译出错 F : 以上都不正确
//class A
//{
//public:
//	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
//
//	virtual void test() { func(); }
//};
//
//class B : public A
//{
//public:
//	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
//};
//
//int main(int argc, char* argv[])
//{
//	B* p = new B;
//	p->test();
//
//	return 0;
//}

// A: A->0 B : B->1 C : A->1 D : B->0 E : 编译出错 F : 以上都不正确

//class Base1 { public: int _b1; };
//class Base2 { public: int _b2; };
//class Derive : public Base2, public Base1 { public: int _d; };
//
//int main() {
//	Derive d;
//	Base1* p1 = &d;
//	Base2* p2 = &d;
//	Derive* p3 = &d;
//
//	return 0;
//}

// class Car
// {
// public:
// 	// 虚函数不能被重写
// 	virtual void Drive() final {}
// };

// class Benz :public Car
// {
// public:
// 	virtual void Drive() { cout << "Benz-舒适" << endl; }
// };

// //一个不能类被继承

// //C++11的方法: final修饰的类叫最终类，不能继承
// class Car final
// {
// public:

// private:
// 	// C++98的方法：父类的构造函数私有
// 	// 子类的构造无法生成和实现，导致子类对象无法实例化
// 	Car()
// 	{}
// };

// class Benz :public Car
// {
// public:

// };

// int main()
// {
// 	//Benz b;

// 	return 0;
// }

//class Car {
//public:
//	virtual void Drive() {}
//};
//
//class Benz :public Car {
//public:
//	// 加到子类的重写虚函数，检查是否完成重写
//	virtual void Drive() override { cout << "Benz-舒适" << endl;  }
//};
//
//int main()
//{
//	Benz b;
//
//	return 0;
//}

//class Base
//{
//public:
//	virtual void Func1()
//	{
//		cout << "Func1()" << endl;
//	}
//private:
//	// 虚函数表指针，简称虚表指针(只要有虚函数就有这个)
//	int _b = 1;
//	char _ch = 'x';
//};
//
//int main()
//{
//	cout << sizeof(Base) << endl;
//	Base b;
//
//	return 0;
//}

//class Base
//{
//public:
//	virtual void Func1()
//	{
//		cout << "Base::Func1()" << endl;
//	}
//	virtual void Func2()
//	{
//		cout << "Base::Func2()" << endl;
//	}
//	void Func3()
//	{
//		cout << "Base::Func3()" << endl;
//	}
//private:
//	int _b = 1;
//};
//
//int main()
//{
//	Base b;
//
//	return 0;
//}

//class Person {
//public:
//	void BuyTicket() { cout << "买票-全价" << endl; }
//
//private:
//	int _i = 1;
//};
//
//class Student : public Person {
//public:
//	virtual void BuyTicket() { cout << "买票-半价" << endl; }
//
//	int _j = 2;
//};
//
//void Func(Person* p)
//{
//	p->BuyTicket();
//}
//
//int main()
//{
//	Person Mike;
//	Func(&Mike);
//
//	Person p1;
//	Func(&p1);
//
//	Student Johnson;
//	Func(&Johnson);
//
//	return 0;
//}

// class Base {
// public:
// 	virtual void func1() { cout << "Base::func1" << endl; }
// 	virtual void func2() { cout << "Base::func2" << endl; }
// private:
// 	int a = 1;
// };

// class Derive :public Base {
// public:
// 	virtual void func1() { cout << "Derive::func1" << endl; }
// 	virtual void func3() { cout << "Derive::func3" << endl; }
// 	virtual void func4() { cout << "Derive::func4" << endl; }
// private:
// 	int b = 2;
// };

// // 打印对象虚表
// typedef void(*VFPTR)();

// // 打印函数指针数组
// // virtual function table
// //void PrintVFT(VFPTR vft[])
// void PrintVFT(VFPTR* vft)
// {
// 	for (size_t i = 0; i < 4; i++)
// 	{
// 		printf("%p->", vft[i]);

// 		VFPTR pf = vft[i];
// 		(*pf)();
// 		//pf();
// 	}
// }

// int main()
// {
// 	Base b;
// 	Derive d;

// 	//int ptr = (int)d; // 不支持转换，只有有关联的类型才能互相转
// 	VFPTR* ptr = (VFPTR*)(*((int*)&d));
// 	PrintVFT(ptr);

// 	// 函数指针
// 	void (*p1)();
// 	VFPTR p2;

// 	// 函数指针数组
// 	void (*pa1[10])();
// 	VFPTR pa2[10];


// 	return 0;
// }